home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_src.lha / LEDA-3.1c-source / src / vga / _vgawin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-17  |  25.0 KB  |  1,116 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _vgawin.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vga.h"
  18.  
  19. /*----------------------------------------------------------------------------*/
  20. /* event handling, window manager, etc ...                                    */
  21. /*----------------------------------------------------------------------------*/
  22.  
  23. #define BORDER_W 5
  24. #define HEADER_W 20 
  25.  
  26. VgaWindow  win_stack[16];
  27. int win_top = 0;
  28.  
  29. static int display = 0;
  30. static int mouse_installed=0;
  31. static int mouse_two_buttons=0;
  32.  
  33. static VgaWindow root_win = 0;
  34.  
  35. static int root_color = 14; // grey 
  36.  
  37. static int pointer_shape = 0;
  38. static int mouse_x = DISP_WIDTH/2;
  39. static int mouse_y = DISP_HEIGHT/2;
  40.  
  41. static int event_buffer_e = -1;
  42. static int event_buffer_val;
  43. static VgaWindow event_buffer_win;
  44.  
  45. static int last_event_e;
  46. static int last_event_val;
  47. static VgaWindow last_event_win;
  48.  
  49. static int pointer_visible = 0;
  50.  
  51. static int save_mode;
  52. static int save_lw;
  53. static int save_ls;
  54.  
  55.  
  56. static unsigned char pointer_mask[2][2][14] = { 
  57. {{0xc0,0xf0,0x7c,0x7f,0x3f,0x3f,0x1f,0x1f,0x0d,0x0c,0x00,0x00,0x00,0x00},
  58.  {0x00,0x00,0x00,0x00,0xc0,0xc0,0x00,0x80,0xc0,0xe0,0x70,0x38,0x1c,0x0c}},
  59.  
  60. {{0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x01,0x03,0x07,0x0e,0x1c,0x38,0x30},
  61.  {0x03,0x0f,0x3e,0xfe,0xfc,0xfc,0xf8,0xf8,0xb0,0x30,0x00,0x00,0x00,0x00} }
  62. };
  63.  
  64.  
  65. static void draw_pointer()
  66. {
  67.   register int x1 = mouse_x % 8;
  68.   register int x2 = 8-x1;
  69.   register int x = mouse_x/8;
  70.   VIDEO_PTR start = VIDEO + LINE_BYTES*mouse_y + x;
  71.   register VIDEO_PTR q;
  72.   register unsigned char c;
  73.  
  74.   set_color(black);
  75.  
  76.   if (pointer_shape == 1)
  77.   { pixel(root_win->id,mouse_x-2,mouse_y);
  78.     pixel(root_win->id,mouse_x-1,mouse_y);
  79.     pixel(root_win->id,mouse_x,mouse_y);
  80.     pixel(root_win->id,mouse_x+1,mouse_y);
  81.     pixel(root_win->id,mouse_x+3,mouse_y);
  82.     pixel(root_win->id,mouse_x,mouse_y-2);
  83.     pixel(root_win->id,mouse_x,mouse_y-1);
  84.     pixel(root_win->id,mouse_x,mouse_y+1);
  85.     pixel(root_win->id,mouse_x,mouse_y+2);
  86.     circle(root_win->id,mouse_x,mouse_y,6);
  87.     return;
  88.    }
  89.  
  90.  
  91.   int a = 0;
  92.   int b = 14;
  93.   int d = 1;
  94.   int k = 0;
  95.  
  96.   if (mouse_y + 15 > DISP_MAX_Y) 
  97.   { a = 13;
  98.     b = -1;
  99.     d = -1;
  100.     start -= 14*LINE_BYTES;
  101.    }
  102.  
  103.   if (x > 77) 
  104.   { start -= 2;
  105.     k = 1;
  106.    }
  107.  
  108.   port_out(8, GRA_I);
  109.  
  110.   for(int i=a; i!=b; i+=d)
  111.   { q = start;
  112.     c = (pointer_mask[k][0][i]>>x1);
  113.     port_out(c, GRA_D);
  114.     *q = *q;
  115.     ++q; 
  116.     c = ((pointer_mask[k][1][i]>>x1) | (pointer_mask[k][0][i]<<x2));
  117.     port_out(c, GRA_D);
  118.     *q = *q;
  119.     
  120.     if (x2)
  121.     { ++q;
  122.       c = (pointer_mask[k][1][i]<<x2);
  123.       port_out(c, GRA_D);
  124.       *q = *q;
  125.      }
  126.     start+=LINE_BYTES;
  127.    }
  128. }
  129.  
  130. static void show_pointer()
  131. { if (!pointer_visible) draw_pointer(); 
  132.   pointer_visible = 1;
  133.  }
  134.  
  135. static void hide_pointer()
  136. { if (pointer_visible) draw_pointer(); 
  137.   pointer_visible = 0;
  138.  }
  139.  
  140.  
  141. static void set_pointer_shape(int shape)
  142. { if (pointer_shape != shape) 
  143.   { draw_pointer();
  144.     pointer_shape = shape;
  145.     draw_pointer();
  146.   }
  147.  }
  148.  
  149.  
  150. static void save_box(VgaWindow win)
  151. { register int y;
  152.   register VIDEO_PTR p;
  153.   register VIDEO_PTR q;
  154.   register VIDEO_PTR first;
  155.   register VIDEO_PTR last;
  156.  
  157.   if (win_top <= 1) { win->plane[0] = 0; return; }
  158.  
  159.   int left   = win->x0;
  160.   int top    = win->y0;
  161.   int right  = win->x1;
  162.   int bottom = win->y1;
  163.  
  164.   int i,l,r;
  165.  
  166.   if(left < 0) left = 0;
  167.   if(top  < 0) top = 0;
  168.   if(right  > DISP_MAX_X) right = DISP_MAX_X;
  169.   if(bottom > DISP_MAX_Y) bottom = DISP_MAX_Y;
  170.  
  171.   l = (left>>3);
  172.   r = (right>>3);
  173.  
  174.   win->plane[0] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  175.   win->plane[1] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  176.   win->plane[2] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  177.   win->plane[3] = (VIDEO_PTR)malloc((r-l+1)*(bottom-top+1));
  178.  
  179.   /* set read mode 0 */
  180.   port_out(5, GRA_I);
  181.   port_out(0, GRA_D);
  182.  
  183.   /* read planes 0 to 3 */
  184.   for(i=0; i<4; i++)
  185.   { p = win->plane[i];
  186.  
  187.     port_out(4, GRA_I);
  188.     port_out(i, GRA_D);
  189.  
  190.     first = VIDEO + LINE_BYTES*top + l;
  191.     last  = VIDEO + LINE_BYTES*top + r;
  192.  
  193.     for(y=top; y<=bottom; y++)
  194.     { for(q=first; q<=last; q++) *p++ = *q;
  195.       first  += LINE_BYTES;
  196.       last   += LINE_BYTES;
  197.      }
  198.   }
  199. }
  200.  
  201.  
  202.  
  203. static void restore_box(VgaWindow win, int left, int top, int right, int bottom)
  204. { register int y;
  205.   register VIDEO_PTR p;
  206.   register VIDEO_PTR q;
  207.   register VIDEO_PTR first;
  208.   register VIDEO_PTR last;
  209.   int save_mode;
  210.   int save_col;
  211.   int i;
  212.  
  213.   if(left < 0) left = 0;
  214.   if(top  < 0) top = 0;
  215.   if(right  > DISP_MAX_X) right = DISP_MAX_X;
  216.   if(bottom > DISP_MAX_Y) bottom = DISP_MAX_Y;
  217.  
  218.   save_mode = set_mode(0);
  219.  
  220.   if (win->plane[0])
  221.      save_col = set_color(0);
  222.   else
  223.      save_col = set_color(root_color);
  224.  
  225.  
  226.   // clean area
  227.  
  228.   port_out(8, GRA_I);
  229.   port_out(0xFF, GRA_D);
  230.   first  = VIDEO + LINE_BYTES*top + left/8;
  231.   last   = VIDEO + LINE_BYTES*top + right/8;
  232.   for(y=top; y<=bottom; y++)
  233.   { for(q=first; q<=last; q++) *q = *q;
  234.     first  += LINE_BYTES;
  235.     last   += LINE_BYTES;
  236.    }
  237.  
  238.  
  239.   // fill in plane data
  240.  
  241.   set_mode(2); /* or */
  242.  
  243.   if (win->plane[0])
  244.     for(i = 0; i < 4; i++)
  245.     {
  246.       p = win->plane[i];
  247.   
  248.       set_color(1<<i);
  249.   
  250.       first  = VIDEO + LINE_BYTES*top + left/8;
  251.       last   = VIDEO + LINE_BYTES*top + right/8;
  252.   
  253.       port_out(8, GRA_I);
  254.   
  255.       for(y=top; y<=bottom; y++)
  256.       { for(q=first; q<=last; q++,p++) 
  257.         { port_out(*p, GRA_D);
  258.           *q = *q;
  259.          }
  260.         first  += LINE_BYTES;
  261.         last   += LINE_BYTES;
  262.        }
  263.   
  264.       free((char*)win->plane[i]);
  265.     }
  266.   
  267.     set_mode(save_mode);
  268.     set_color(save_col);
  269. }
  270.  
  271.  
  272. static void put_header(VgaWindow win)
  273. { char str[80];
  274.   int n = (win->width - 40)/text_width("H");
  275.   strncpy(str,win->header,n);
  276.   str[n] = 0;
  277.   put_ctext(root_win->id,win->x0 + win->width/2 + 20, win->y0 + 10 ,str,0);
  278.  }
  279.  
  280. static void set_header(VgaWindow win, const char* s)
  281. { int save_co = set_color(win->label_col);
  282.   int save_mo = set_mode(0);
  283.   put_header(win);
  284.   if (s != win->header) strcpy(win->header,s);
  285.   set_color(1);
  286.   put_header(win);
  287.   set_color(save_co);
  288.   set_mode(save_mo);
  289.  }
  290.  
  291. void set_header(Window win, const char* s) { set_header(win_stack[win],s); }
  292.  
  293.  
  294.  
  295. static void draw_window(VgaWindow win)
  296. {
  297.   int bw  = win->xpos - win->x0 - 2;
  298.   int lw  = win->ypos - win->y0 - 2;
  299.   int bw1 = 2*(bw+1);
  300.  
  301.   int x0 = win->x0;
  302.   int y0 = win->y0;
  303.  
  304.   int x1 = win->x1;
  305.   int y1 = win->y1;
  306.  
  307.   int save_mode = set_mode(0);
  308.  
  309.   set_color(win->bg_col);
  310.   box(root_win->id,x0,y0,x1,y1);
  311.   set_color(win->label_col);
  312.   box(root_win->id,x0+bw,y0+bw,x1-bw,y0+lw);
  313.   box(root_win->id,x0,y0+bw1,x0+bw,y1-bw1);
  314.   box(root_win->id,x1-bw,y0+bw1,x1,y1-bw1);
  315.   box(root_win->id,x0+bw1,y1-bw,x1-bw1,y1);
  316.   box(root_win->id,x0+bw1,y0,x1-bw1,y0+bw);
  317.   set_color(1);
  318.  
  319.   rectangle(root_win->id,x0,y0,x1,y1);
  320.  
  321.   line(root_win->id,x0+bw,y0+bw,x0+bw1,y0+bw);
  322.   line(root_win->id,x0+bw1,y0+bw,x0+bw1,y0+1);
  323.   line(root_win->id,x0+bw1,y0+1,x1-bw1,y0+1);
  324.   line(root_win->id,x1-bw1,y0+1,x1-bw1,y0+bw);
  325.   line(root_win->id,x1-bw1,y0+bw,x1-bw,y0+bw);
  326.   line(root_win->id,x1-bw,y0+bw,x1-bw,y0+bw1);
  327.   line(root_win->id,x1-bw,y0+bw1,x1-1,y0+bw1);
  328.   line(root_win->id,x1-1,y0+bw1,x1-1,y1-bw1);
  329.   line(root_win->id,x1-1,y1-bw1,x1-bw,y1-bw1);
  330.   line(root_win->id,x1-bw,y1-bw1,x1-bw,y1-bw);
  331.   line(root_win->id,x1-bw,y1-bw,x1-bw1,y1-bw);
  332.   line(root_win->id,x1-bw1,y1-bw,x1-bw1,y1-1);
  333.   line(root_win->id,x1-bw1,y1-1,x0+bw1,y1-1);
  334.   line(root_win->id,x0+bw1,y1-1,x0+bw1,y1-bw);
  335.   line(root_win->id,x0+bw1,y1-bw,x0+bw,y1-bw);
  336.   line(root_win->id,x0+bw,y1-bw,x0+bw,y1-bw1);
  337.   line(root_win->id,x0+bw,y1-bw1,x0+1,y1-bw1);
  338.   line(root_win->id,x0+1,y1-bw1,x0+1,y0+bw1);
  339.   line(root_win->id,x0+1,y0+bw1,x0+bw,y0+bw1);
  340.   line(root_win->id,x0+bw,y0+bw1,x0+bw,y0+bw);
  341.  
  342.   rectangle(root_win->id, win->xpos-1, win->ypos-1,
  343.                       win->xpos+win->width, win->ypos+win->height);
  344.  
  345.   // iconize-button
  346.   set_color(0);
  347.   box(root_win->id,x0+13,y0+3,x0+27,y0+15);
  348.   set_color(1);
  349.   rectangle(root_win->id,x0+13,y0+3,x0+27,y0+15);
  350.   line(root_win->id,x0+14,y0+16,x0+28,y0+16);
  351.   line(root_win->id,x0+28,y0+4,x0+28,y0+15);
  352.   line(root_win->id,x0+17,y0+6,x0+23,y0+6);
  353.   line(root_win->id,x0+16,y0+6,x0+20,y0+13);
  354.   line(root_win->id,x0+17,y0+6,x0+20,y0+13);
  355.   line(root_win->id,x0+24,y0+6,x0+20,y0+13);
  356.   line(root_win->id,x0+23,y0+6,x0+20,y0+13);
  357.  
  358.   set_header(win->id,win->header);
  359.  
  360.   set_mode(save_mode);
  361.  
  362. }
  363.  
  364.  
  365. Window open_window(int x,int y,int width,int height,const char* header,
  366.                                                     const char* label)
  367. { 
  368.   VgaWindow win = new vga_window;
  369.  
  370.   win_stack[++win_top] = win;
  371.   win->id = win_top;
  372.  
  373.   strcpy(win->header," ");
  374.   strcpy(win->label,label);
  375.  
  376.   if ( strcmp(label,"PANEL") == 0)
  377.      { win->bg_col = white; // grey
  378.        win->label_col = violet;
  379.       }
  380.   else
  381.      { win->bg_col = white;
  382.        win->label_col = yellow;
  383.       }
  384.  
  385.   width  += 2*BORDER_W;
  386.   height += HEADER_W+BORDER_W;
  387.  
  388.   if (width > DISP_WIDTH) width = DISP_WIDTH;
  389.   if (height > DISP_HEIGHT) height = DISP_HEIGHT;
  390.  
  391.   if (x+width > DISP_WIDTH) x = DISP_WIDTH - width;
  392.   if (x < 0) x = 0;
  393.   if (y+height > DISP_HEIGHT) y = DISP_HEIGHT - height;
  394.   if (y < 0) y = 0;
  395.  
  396.   win->x0 = x;
  397.   win->y0 = y;
  398.   win->x1 = x+width-1;
  399.   win->y1 = y+height-1;
  400.   win->xpos = x+BORDER_W;
  401.   win->ypos = y+HEADER_W;
  402.   win->width = width - 2*BORDER_W; 
  403.   win->height = height - HEADER_W - BORDER_W;
  404.  
  405.   win->iconized = 0;
  406.   win->save_x0 = 3;
  407.   win->save_y0 = 3 + 150*(win_top-1);
  408.   win->save_x1 = win->save_x0 + 128 + 2*BORDER_W;
  409.   win->save_y1 = win->save_y0 + 128 + HEADER_W + BORDER_W;
  410.   win->save_bg_col = white;
  411.  
  412.   save_box(win);
  413.   draw_window(win);
  414.   set_header(win->id,header);
  415.   return win->id;
  416. }
  417.  
  418.  
  419. void close_window(Window w)
  420. { VgaWindow win = win_stack[win_top];  /* can close top window only */
  421.   restore_box(win,win->x0,win->y0,win->x1,win->y1);
  422.   win_top--;
  423.   delete win;
  424.  }
  425.  
  426.  
  427.  
  428.  
  429.  
  430. void set_read_gc()
  431. { save_mode = set_mode(1);
  432.   save_ls   = set_line_style(0);
  433.   save_lw   = set_line_width(1);
  434.   set_color(1);
  435.   show_pointer();
  436.  }
  437.  
  438. void reset_gc()
  439. { hide_pointer();
  440.   set_mode(save_mode);
  441.   set_line_style(save_ls);
  442.   set_line_width(save_lw);
  443.  }
  444.  
  445.  
  446. #define UP  72
  447. #define DO  80
  448. #define LE  75
  449. #define RI  77
  450.  
  451. #define F1  59
  452. #define F2  60
  453. #define F3  61
  454. #define F4  62
  455. #define SF1 84
  456. #define SF2 85
  457. #define SF3 86
  458. #define CF1 94
  459. #define CF2 95
  460. #define CF3 96
  461.  
  462. static int handle_next_event(Window* win, int *val, int *x, int *y)
  463. {
  464.   int  e =  no_event;
  465.   int  i;
  466.   VgaWindow w;
  467.  
  468.   union REGS key_regs;
  469.   union REGS mouse_regs;
  470.  
  471.   if (event_buffer_e != -1)
  472.   { *val = event_buffer_val;
  473.     w = event_buffer_win;
  474.     *win = w->id;
  475.     *x = mouse_x - w->xpos;
  476.     *y = mouse_y - w->ypos;
  477.     last_event_e = event_buffer_e;
  478.     last_event_val = event_buffer_val;
  479.     last_event_win = event_buffer_win;
  480.     event_buffer_e = -1;
  481.     return last_event_e;
  482.    }
  483.  
  484.   mouse_regs.x.cx = 8*mouse_x;
  485.   mouse_regs.x.dx = 8*mouse_y;
  486.  
  487.   if (kbhit())
  488.   { 
  489.     char c = getch();
  490.  
  491.     int step = 8;
  492.  
  493.     if (c==27) 
  494.     { close_display();
  495.       exit(0);
  496.      }
  497.  
  498.     if (c != 0)   /* ascii char */
  499.        { *val = c;
  500.          e = key_press_event;
  501.         }
  502.     else          /* cursor or function key  */
  503.        { 
  504.          c = getch();
  505.  
  506.          switch(c) {
  507.  
  508.          case  LE: mouse_regs.x.cx -= step;
  509.                    e = motion_event;
  510.                    break;
  511.  
  512.          case  RI: mouse_regs.x.cx += step;
  513.                    e = motion_event;
  514.                    break;
  515.  
  516.          case  UP: mouse_regs.x.dx -= step;
  517.                    e = motion_event;
  518.                    break;
  519.  
  520.          case  DO: mouse_regs.x.dx += step;
  521.                    e = motion_event;
  522.                    break;
  523.  
  524.          case  F1: *val = 1;
  525.                    e = button_press_event;
  526.                    break;
  527.  
  528.          case  F2: *val = 2;
  529.                    e = button_press_event;
  530.                    break;
  531.  
  532.          case  F3: *val = 3;
  533.                    e = button_press_event;
  534.                    break;
  535.  
  536.          case  F4: *val = 1;
  537.                    e = button_release_event;
  538.                    break;
  539.  
  540.          case SF1: *val = -1;
  541.                    e = button_press_event;
  542.                    break;
  543.  
  544.          case SF2: *val = -2;
  545.                    e = button_press_event;
  546.                    break;
  547.  
  548.          case SF3: *val = -3;
  549.                    e = button_press_event;
  550.                    break;
  551.  
  552.          case CF1: *val = 4;
  553.                    e = button_press_event;
  554.                    break;
  555.  
  556.          case CF2: *val = 5;
  557.                    e = button_press_event;
  558.                    break;
  559.  
  560.          case  CF3: *val = 6;
  561.                    e = button_press_event;
  562.                    break;
  563.         }
  564.  
  565.         /* set cursor position */
  566.         mouse_regs.x.ax=04;
  567.         int86(0x33,&mouse_regs,&mouse_regs);
  568.       }
  569.  
  570.    } /* kbhit */
  571.  
  572.  else
  573.  
  574.   if (mouse_installed)
  575.   { 
  576.     int but;
  577.  
  578.     /* check for button press and release events */
  579.  
  580. //INT 33 - MS MOUSE - RETURN BUTTON PRESS DATA
  581. //    AX = 0005h
  582. //    BX = button
  583. //        0000h left
  584. //        0001h right
  585. //        0002h middle (Mouse Systems/Logitech mouse)
  586. //Return: AX = 1 if button pressed
  587. //      BX = number of times specified button has been pressed since last call
  588. //      CX = column at time specified button was last pressed
  589. //      DX = row at time specified button was last pressed
  590.  
  591. //INT 33 - MS MOUSE - RETURN BUTTON RELEASE DATA
  592. //    AX = 0006h
  593. //    BX = button
  594. //        0000h left
  595. //        0001h right
  596. //        0002h middle (Mouse Systems/Logitech mouse)
  597. //Return: AX = 1 if button released
  598. //      BX = # of times specified button has been released since last call
  599. //      CX = column at time specified button was last released
  600. //      DX = row at time specified button was last released
  601.  
  602.     for(but=0; but < 3; but++)
  603.     { 
  604.       mouse_regs.x.ax=5;
  605.       mouse_regs.x.bx=but;
  606.       int86(0x33,&mouse_regs,&mouse_regs);
  607.  
  608.       if (mouse_regs.x.bx)
  609.       { e = button_press_event;
  610.         break;
  611.        }
  612.  
  613.       mouse_regs.x.ax=6;
  614.       mouse_regs.x.bx=but;
  615.       int86(0x33,&mouse_regs,&mouse_regs);
  616.  
  617.       if (mouse_regs.x.bx)
  618.       { e = button_release_event;
  619.         break;
  620.        }
  621.  
  622.      }
  623.  
  624.  
  625.     if (but < 3) 
  626.     { 
  627.       if (but == 0) *val = 1;   // left
  628.       if (but == 1) *val = 3;   // right
  629.  
  630.       //INT 16 - GET KEYBOARD SHIFT KEY STATES
  631.       //          AH = 0002h
  632.       //  OUTPUT: AL  bit 0    right shift
  633.       //              bit 1    left shift
  634.       //              bit 2    ctrl
  635.       //              bit 3    alt
  636.  
  637.       key_regs.h.ah=0x02;
  638.       int86(0x16,&key_regs,&key_regs);
  639.  
  640.       // ALT key simulates middle button  (two-button mouse)
  641.       if (key_regs.h.al & 8) *val = 2; 
  642.  
  643.       if (key_regs.h.al & 3) *val = -*val;   /* shift */
  644.       if (key_regs.h.al & 4) *val += 3;      /* ctrl  */
  645.      }
  646.  
  647.    // INT 33 MS-MOUSE GET CURSOR POSITION
  648.    mouse_regs.x.ax=03;
  649.    int86(0x33,&mouse_regs,&mouse_regs);
  650.   }
  651.  
  652.   if (mouse_regs.x.cx/8 != mouse_x || mouse_regs.x.dx/8 != mouse_y)
  653.   { if (e==no_event) e = motion_event;
  654.     draw_pointer();
  655.     mouse_y = mouse_regs.x.dx/8;
  656.     mouse_x = mouse_regs.x.cx/8;
  657.     draw_pointer();
  658.    }
  659.  
  660.   for(i = win_top; i >= 0; i--)
  661.   { w = win_stack[i];
  662.     if (mouse_x >= w->x0  && mouse_x <= w->x1 &&
  663.         mouse_y >= w->y0  && mouse_y <= w->y1 )  break;
  664.    }
  665.  
  666.   *win = w->id;
  667.   *x = mouse_x - w->xpos;
  668.   *y = mouse_y - w->ypos;
  669.  
  670.   if (e != no_event)
  671.   { last_event_e   = e;
  672.     last_event_val = *val;
  673.     last_event_win = w;
  674.    }
  675.  
  676.   return e;
  677.  }
  678.  
  679.  
  680. void put_back_event() 
  681. { event_buffer_e   = last_event_e;  
  682.   event_buffer_val = last_event_val; 
  683.   event_buffer_win = last_event_win; 
  684.  }
  685.  
  686. static void change_geometry(VgaWindow win, int x0, int y0, int x1, int y1)
  687. {
  688.   if (x0==win->x0 && y0==win->y0 && x1==win->x1 && y1==win->y1) return;
  689.  
  690.   int w = x1-x0+1;
  691.   int h = y1-y0+1;
  692.  
  693.   draw_pointer();
  694.   restore_box(win,win->x0,win->y0,win->x1,win->y1);
  695.  
  696.   win->x0 = x0;
  697.   win->y0 = y0;
  698.   win->x1 = x1;
  699.   win->y1 = y1;
  700.   win->xpos = x0+BORDER_W;
  701.   win->ypos = y0+HEADER_W;
  702.   win->width = w - 2*BORDER_W; 
  703.   win->height = h - HEADER_W - BORDER_W;
  704.  
  705.   save_box(win);
  706.   draw_window(win);
  707.   draw_pointer();
  708. }
  709.  
  710.  
  711. static void iconize(VgaWindow win)
  712. { Window w;
  713.   int val,x,y;
  714.   box(root_win->id,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  715.   while (handle_next_event(&w,&val,&x,&y) != button_release_event);
  716.   box(root_win->id,win->x0+14,win->y0+4,win->x0+26,win->y0+14);
  717.  
  718.   int x0 = win->save_x0;
  719.   int y0 = win->save_y0;
  720.   int x1 = win->save_x1;
  721.   int y1 = win->save_y1;
  722.   int bg = win->save_bg_col;
  723.   win->save_x0 = win->x0;
  724.   win->save_y0 = win->y0;
  725.   win->save_x1 = win->x1;
  726.   win->save_y1 = win->y1;
  727.   win->save_bg_col = win->bg_col;
  728.   win->bg_col =  bg;
  729.   change_geometry(win,x0,y0,x1,y1);
  730.   win->iconized = 1-win->iconized;
  731.  
  732.   if (win->iconized) 
  733.      insert_bitmap(win->id, leda_icon_width, leda_icon_height, leda_icon_bits);
  734.  }
  735.  
  736. static void move_win(VgaWindow win, int *x, int *y)
  737. { int xp0 = win->x0;
  738.   int yp0 = win->y0;
  739.   int xp1 = win->x1;
  740.   int yp1 = win->y1;
  741.   int wi  = xp1-xp0+1;
  742.   int he  = yp1-yp0+1;
  743.   int xb  = win->xpos - xp0;
  744.   int yb  = win->ypos - yp0;
  745.   int xc = mouse_x; /* absolute cursor coordinates */
  746.   int yc = mouse_y; 
  747.   int dx = xc-xp0;  /* relative to upper left corner */
  748.   int dy = yc-yp0;
  749.  
  750.   Window w;
  751.   int e,val;
  752.  
  753.   rectangle(root_win->id,xp0-1,yp0-1,xp1+1,yp1+1);
  754.  
  755.   do { e = handle_next_event(&w,&val,x,y);
  756.       if (mouse_x != xc || mouse_y != yc)
  757.        { int rx0 = mouse_x-dx-1;
  758.          int ry0 = mouse_y-dy-1;
  759.          int rx1 = mouse_x-dx+wi;
  760.          int ry1 = mouse_y-dy+he;
  761.          rectangle(root_win->id,rx0,ry0,rx1,ry1);
  762.          rectangle(root_win->id,xc-dx-1,yc-dy-1,xc-dx+wi,yc-dy+he);
  763.          xc = mouse_x;
  764.          yc = mouse_y;
  765.        }
  766.      } while (e != button_release_event);
  767.  
  768.   xc -= dx;
  769.   yc -= dy;
  770.  
  771.   rectangle(root_win->id,xc-1,yc-1,xc+wi,yc+he);
  772.  
  773.   if (xc < 0) xc = 0;
  774.   if (yc < 0) yc = 0;
  775.   if (xc + wi > DISP_MAX_X) xc = DISP_MAX_X - wi;
  776.   if (yc + he > DISP_MAX_Y) yc = DISP_MAX_Y - he;
  777.  
  778.   if (win_top > 1)  /* move panel */
  779.   { change_geometry(win,xc,yc,xc+wi-1,yc+he-1);
  780.     if (win->iconized) 
  781.        insert_bitmap(win->id, leda_icon_width, leda_icon_height, leda_icon_bits);
  782.     return;
  783.    }
  784.  
  785.   xc -= xc % 8;
  786.   xc += xp0 % 8;
  787.  
  788.   draw_pointer();
  789.   copy_rect(root_win->id,xp0,yp0+1,xp0+wi,yp0+he-1,xc,yc+1);
  790.   draw_pointer();
  791.  
  792.   set_mode(0);
  793.   set_color(root_color);
  794.  
  795.   if (xc > xp0) 
  796.      box(root_win->id,xp0,yp0,xc-1,yp1);
  797.   else
  798.      box(root_win->id,xc+wi,yp0,xp1,yp1);
  799.  
  800.   if (yc > yp0) 
  801.      box(root_win->id,xp0,yp0,xp1,yc-1);
  802.   else
  803.      box(root_win->id,xp0,yc+he,xp1,yp1);
  804.  
  805.   set_color(1);
  806.   rectangle(root_win->id,xc,yc,xc+wi-1,yc+he-1);
  807.  
  808.   set_mode(1);
  809.  
  810.   win->x0 = xc; 
  811.   win->y0 = yc; 
  812.   win->x1 = xc+wi-1; 
  813.   win->y1 = yc+he-1; 
  814.   win->xpos = xc+xb; 
  815.   win->ypos = yc+yb; 
  816.  
  817. }
  818.  
  819.  
  820. static void resize_win(VgaWindow win, int* x, int* y, int pos)
  821. { int xp0 = win->x0;
  822.   int yp0 = win->y0;
  823.   int xp1 = win->x1;
  824.   int yp1 = win->y1;
  825.   int xb  = win->xpos - xp0;
  826.   int yb  = win->ypos - yp0;
  827.   
  828.   int xc  = mouse_x; /* absolute cursor coordinates */
  829.   int yc  = mouse_y;
  830.  
  831.   Window w;
  832.   int e,val,dx,dy;
  833.  
  834.   rectangle(root_win->id,xp0-1,yp0-1,xp1+1,yp1+1);
  835.  
  836.   switch(pos) {
  837.   
  838.    case 0: dx = xp0-xc;          /* upper left */
  839.            dy = yp0-yc;
  840.            break;
  841.  
  842.    case 1: dx = xp1-xc;          /* upper right */
  843.            dy = yp0-yc;
  844.            break;
  845.  
  846.    case 2: dx = xp1-xc;          /* lower right */
  847.            dy = yp1-yc;
  848.            break;
  849.  
  850.    case 3: dx = xp0-xc;          /* lower left */
  851.            dy = yp1-yc;
  852.            break;
  853.  
  854.    }
  855.  
  856.   do { e = handle_next_event(&w,&val,x,y);
  857.        if (mouse_x != xc || mouse_y != yc)
  858.         { 
  859.           switch(pos) {
  860.  
  861.           case 0: rectangle(root_win->id,mouse_x+dx-1,mouse_y+dy-1,xp1+1,yp1+1);
  862.                   rectangle(root_win->id,xc+dx-1,yc+dy-1,xp1+1,yp1+1);
  863.                   break;
  864.           
  865.           case 1: rectangle(root_win->id,xp0-1,mouse_y+dy-1,mouse_x+dx+1,yp1+1);
  866.                   rectangle(root_win->id,xp0-1,yc+dy-1,xc+dx+1,yp1+1);
  867.                   break;
  868.  
  869.           case 2: rectangle(root_win->id,xp0-1,yp0-1,mouse_x+dx+1,mouse_y+dy+1);
  870.                   rectangle(root_win->id,xp0-1,yp0-1,xc+dx+1,yc+dy+1);
  871.                   break;
  872.              
  873.           case 3: rectangle(root_win->id,mouse_x+dx-1,yp0-1,xp1+1,mouse_y+dy+1);
  874.                   rectangle(root_win->id,xc+dx-1,yp0-1,xp1+1,yc+dy+1);
  875.                   break;
  876.           
  877.            }
  878.  
  879.           xc = mouse_x;
  880.           yc = mouse_y;
  881.         }
  882.      } while (e != button_release_event);
  883.  
  884.    xc += dx;
  885.    yc += dy;
  886.  
  887.    switch(pos) {
  888.  
  889.    case 0: win->x0 = xc; 
  890.            win->y0 = yc; 
  891.            break;
  892.                 
  893.    case 1: win->x1 = xc; 
  894.            win->y0 = yc; 
  895.            break;
  896.               
  897.    case 2: win->x1 = xc; 
  898.            win->y1 = yc; 
  899.            break;
  900.  
  901.    case 3: win->x0 = xc; 
  902.            win->y1 = yc; 
  903.            break;
  904.            
  905.    }
  906.  
  907.   win->xpos = win->x0 + xb;
  908.   win->ypos = win->y0 + yb;
  909.   win->width  = win->x1 - win->x0 - 2*xb + 1; 
  910.   win->height = win->y1 - win->y0 - xb - yb + 1; 
  911.  
  912.   rectangle(root_win->id,win->x0-1,win->y0-1,win->x1+1,win->y1+1);
  913.  
  914.   draw_pointer();
  915.  
  916.   restore_box(win,xp0,yp0,xp1,yp1);
  917.  
  918.   save_box(win);
  919.  
  920.   draw_window(win);
  921.  
  922.   draw_pointer();
  923.  
  924.   *x = win->width;
  925.   *y = win->height;
  926.  
  927. }
  928.  
  929.  
  930. int check_next_event(Window* w, int* val, int* x, int *y, unsigned long* t)
  931. {
  932.   // non-blocking
  933.   
  934.   // a primitive window manager active while searching for next event
  935.  
  936.   int cx[4];
  937.   int cy[4];
  938.   int bw = BORDER_W;
  939.   int lw = HEADER_W;
  940.  
  941.   int e = handle_next_event(w,val,x,y);
  942.  
  943.   VgaWindow win = win_stack[*w];
  944.  
  945.   int x0 = win->x0;
  946.   int y0 = win->y0;
  947.   int x1 = win->x1;
  948.   int y1 = win->y1;
  949.  
  950.  
  951.   cx[0] = x0;
  952.   cy[0] = y0;
  953.   cx[1] = x1-6;
  954.   cy[1] = y0;
  955.   cx[2] = x1-6;
  956.   cy[2] = y1-6;
  957.   cx[3] = x0;
  958.   cy[3] = y1-6;
  959.  
  960.   if ( (x0 <= mouse_x && mouse_x <= x0+bw) 
  961.     || (x1 >= mouse_x && mouse_x >= x1-bw)
  962.     || (y0 <= mouse_y && mouse_y <= y0+lw)
  963.     || (y1 >= mouse_y && mouse_y >= y1-bw))
  964.     {
  965.       // pointer on window boundary: move or resize window
  966.  
  967.      if (win != win_stack[win_top])  /* only top window can be changed  */
  968.      { set_pointer_shape(0);
  969.        return no_event;
  970.       }
  971.  
  972.      for(int i=0; i<4; i++)
  973.        if ( cy[i] <= mouse_y && mouse_y <= cy[i]+6 &&
  974.             cx[i] <= mouse_x && mouse_x <= cx[i]+6 )
  975.        { set_pointer_shape(1);
  976.          if (e == button_press_event && ! win->iconized) 
  977.          { if (win->iconized)
  978.              e = no_event;
  979.            else
  980.              resize_win(win,x,y,i);
  981.            e = configure_event;
  982.           }
  983.           return e;
  984.         }
  985.  
  986.     set_pointer_shape(0);
  987.    
  988.     if (x0+13 <= mouse_x && mouse_x <= x0+27 &&
  989.         y0+3  <= mouse_y && mouse_y <= y0+15 && e == button_press_event)
  990.     { iconize(win);
  991.       return (win->iconized) ? no_event : configure_event;
  992.      }
  993.  
  994.  
  995.     if (e== button_press_event) 
  996.     { move_win(win,x,y);
  997.       if (win_top==1 || win->iconized)  
  998.          return handle_next_event(w,val,x,y);  
  999.       else
  1000.          return configure_event;
  1001.      }
  1002.  
  1003.     e = no_event;
  1004.  
  1005.   }  // if pointer on window boundary
  1006.  
  1007.   set_pointer_shape(0);
  1008.  
  1009.   return e;
  1010. }
  1011.  
  1012.  
  1013. int get_next_event(Window* win, int* val, int* x, int *y, unsigned long* t)
  1014. { // blocking
  1015.   int e = no_event;
  1016.   while (e == no_event) e = check_next_event(win,val,x,y,t);
  1017.   return e;
  1018.  }
  1019.  
  1020.  
  1021.  
  1022. void open_display()
  1023. { REGS regs;
  1024.  
  1025.   if (display) return;
  1026.  
  1027.   display = 1;
  1028.  
  1029.   vga_init(1,root_color);
  1030.  
  1031.   //INT 33 - MS MOUSE - RESET DRIVER AND READ STATUS
  1032.   //    AX = 0000h
  1033.   //Return: AX = status
  1034.   //        0000h hardware/driver not installed
  1035.   //        FFFFh hardware/driver installed
  1036.   //        BX = number of buttons
  1037.   //        FFFFh two buttons
  1038.   //        0000h other than two
  1039.   //        0003h Mouse Systems/Logitech mouse
  1040.   regs.x.ax=0x00;
  1041.   int86(0x33,®s,®s);
  1042.   mouse_installed = (regs.x.ax == 0x0ffff);
  1043.   mouse_two_buttons = (regs.x.bx == 0x0ffff);
  1044.  
  1045.   //INT 33 - MS MOUSE - DEFINE HORIZONTAL CURSOR RANGE = 0..DISP_MAX_X
  1046.   regs.x.ax=0x07;
  1047.   regs.x.cx=0;
  1048.   regs.x.dx=8*DISP_MAX_X;
  1049.   int86(0x33,®s,®s);
  1050.  
  1051.   //INT 33 - MS MOUSE - DEFINE VERTICAL CURSOR RANGE = 0..DISP_MAX_Y
  1052.   regs.x.ax=0x08;
  1053.   regs.x.cx=0;
  1054.   regs.x.dx=8*DISP_MAX_Y;
  1055.   int86(0x33,®s,®s);
  1056.  
  1057.   //INT 33 - MS MOUSE - DEFINE MICKEY/PIXEL RATIO = 1
  1058.   regs.x.ax=0x0F;
  1059.   regs.x.cx=1;
  1060.   regs.x.dx=1;
  1061.   int86(0x33,®s,®s);
  1062.  
  1063.   //INT 33 - MS MOUSE - SET CURSOR POSITION
  1064.   mouse_x = DISP_MAX_X/2;
  1065.   mouse_y = DISP_MAX_Y/2;
  1066.   regs.x.cx = 8*mouse_x;
  1067.   regs.x.dx = 8*mouse_y;
  1068.   regs.x.ax=04;
  1069.   int86(0x33,®s,®s);
  1070.  
  1071.   root_win = new vga_window;
  1072.   root_win->id = 0;
  1073.   win_stack[0] = root_win;
  1074.   win_top = 0;
  1075.  
  1076.   root_win->x0 = -1000;
  1077.   root_win->y0 = -1000;
  1078.   root_win->x1 =  1000;
  1079.   root_win->y1 =  1000;
  1080.   root_win->xpos = 0;
  1081.   root_win->ypos = 0;
  1082.   root_win->width = DISP_WIDTH;
  1083.   root_win->height = DISP_HEIGHT;
  1084.   root_win->bg_col = root_color;
  1085.  
  1086.   set_color(root_color);
  1087.   box(root_win->id,0,0,DISP_MAX_X,DISP_MAX_Y);
  1088.   set_color(black);
  1089.   //insert_bitmap(root_win,w,h,leda_bits);
  1090. }
  1091.  
  1092.  
  1093.  
  1094. void close_display()
  1095. { union REGS regs;
  1096.   vga_init(0,0);
  1097.   regs.h.ah=0x00;
  1098.   regs.h.al=0x02;
  1099.   int86(0x10,®s,®s);
  1100.   delete root_win;
  1101. }
  1102.  
  1103.  
  1104. int  display_width() { return DISP_WIDTH; }
  1105. int  display_height(){ return DISP_HEIGHT; }
  1106. int  display_depth() { return DISP_DEPTH; }
  1107.  
  1108. int  window_width(Window win)  { return win_stack[win]->width; }
  1109. int  window_height(Window win) { return win_stack[win]->height; }
  1110.  
  1111. void window_position(Window win,int* x,int* y) 
  1112. { *x = win_stack[win]->x0; 
  1113.   *y = win_stack[win]->y0; 
  1114.  }
  1115.  
  1116.